"""
配置管理模块
提供配置的加载、保存和重置功能
"""

import json
import os
import shutil
from typing import Dict, Any, Optional, Union

class Config:
    """配置管理类"""
    
    def __init__(self, config_file: str = "config.json", default_config_file: str = "default_config.json"):
        """
        初始化配置管理类
        
        Args:
            config_file: 配置文件路径
            default_config_file: 默认配置文件路径
        """
        self.config_file = config_file
        self.default_config_file = default_config_file
        self.config: Dict[str, Any] = {}
        
        # 加载配置
        self._load_config()
    
    def _load_config(self) -> None:
        """加载配置文件"""
        # 如果配置文件不存在，尝试创建默认配置
        if not os.path.exists(self.config_file):
            self._create_default_config()
        
        try:
            with open(self.config_file, 'r', encoding='utf-8') as f:
                self.config = json.load(f)
        except Exception as e:
            print(f"Error loading config file: {str(e)}")
            # 如果加载失败，使用默认配置
            self._create_default_config()
            with open(self.config_file, 'r', encoding='utf-8') as f:
                self.config = json.load(f)
    
    def _create_default_config(self) -> None:
        """创建默认配置文件"""
        # 如果默认配置文件存在，复制它
        if os.path.exists(self.default_config_file):
            shutil.copy(self.default_config_file, self.config_file)
        else:
            # 否则创建一个基本的默认配置
            default_config = {
                "语言": "zh",
                "主题": "light",
                "摘要": {
                    "算法": "extractive",
                    "默认比例": 0.3,
                    "关键词数量": 10
                },
                "文档": {
                    "支持格式": ["txt", "pdf", "docx", "md", "html"],
                    "最大大小": 10485760  # 10MB
                },
                "历史": {
                    "自动保存": True,
                    "最大数量": 100
                },
                "web": {
                    "主机": "127.0.0.1",
                    "端口": 8080
                }
            }
            
            # 确保目录存在
            os.makedirs(os.path.dirname(os.path.abspath(self.config_file)), exist_ok=True)
            
            # 写入默认配置
            with open(self.config_file, 'w', encoding='utf-8') as f:
                json.dump(default_config, f, ensure_ascii=False, indent=4)
    
    def get(self, key: Optional[str] = None, default: Any = None) -> Any:
        """
        获取配置值
        
        Args:
            key: 配置键，使用点号分隔的路径，如 'web.端口'，如果为None则返回整个配置
            default: 如果键不存在时返回的默认值
            
        Returns:
            Any: 配置值或默认值
        """
        if key is None:
            return self.config
        
        # 按路径查找配置
        keys = key.split('.')
        value = self.config
        
        try:
            for k in keys:
                value = value[k]
            return value
        except (KeyError, TypeError):
            return default
    
    def set(self, key: str, value: Any) -> None:
        """
        设置配置值
        
        Args:
            key: 配置键，使用点号分隔的路径
            value: 配置值
        """
        # 按路径设置配置
        keys = key.split('.')
        config = self.config
        
        # 遍历路径直到最后一个键
        for i, k in enumerate(keys[:-1]):
            # 如果键不存在或不是字典，创建一个新字典
            if k not in config or not isinstance(config[k], dict):
                config[k] = {}
            config = config[k]
        
        # 设置最后一个键的值
        config[keys[-1]] = value
    
    def save(self) -> bool:
        """
        保存配置到文件
        
        Returns:
            bool: 是否保存成功
        """
        try:
            # 确保目录存在
            os.makedirs(os.path.dirname(os.path.abspath(self.config_file)), exist_ok=True)
            
            # 写入配置
            with open(self.config_file, 'w', encoding='utf-8') as f:
                json.dump(self.config, f, ensure_ascii=False, indent=4)
            return True
        except Exception as e:
            print(f"Error saving config file: {str(e)}")
            return False
    
    def reset(self) -> bool:
        """
        重置配置为默认值
        
        Returns:
            bool: 是否重置成功
        """
        try:
            # 如果默认配置文件存在，复制它
            if os.path.exists(self.default_config_file):
                shutil.copy(self.default_config_file, self.config_file)
                self._load_config()
            else:
                # 否则创建一个新的默认配置
                self._create_default_config()
                self._load_config()
            return True
        except Exception as e:
            print(f"Error resetting config: {str(e)}")
            return False
    
    def update(self, new_config: Dict[str, Any]) -> bool:
        """
        更新配置
        
        Args:
            new_config: 新的配置字典
            
        Returns:
            bool: 是否更新成功
        """
        try:
            self._update_dict(self.config, new_config)
            return self.save()
        except Exception as e:
            print(f"Error updating config: {str(e)}")
            return False
    
    def _update_dict(self, target: Dict[str, Any], source: Dict[str, Any]) -> None:
        """
        递归更新字典
        
        Args:
            target: 目标字典
            source: 源字典
        """
        for key, value in source.items():
            if key in target and isinstance(target[key], dict) and isinstance(value, dict):
                self._update_dict(target[key], value)
            else:
                target[key] = value

# 创建全局实例
config = Config()

def init_config(config_file: str = "config.json", default_config_file: str = "default_config.json") -> Config:
    """
    初始化全局配置实例
    
    Args:
        config_file: 配置文件路径
        default_config_file: 默认配置文件路径
        
    Returns:
        Config: 配置实例
    """
    global config
    config = Config(config_file, default_config_file)
    return config

def get_config(key: Optional[str] = None, default: Any = None) -> Any:
    """
    获取配置值的快捷方法
    
    Args:
        key: 配置键
        default: 默认值
        
    Returns:
        Any: 配置值
    """
    return config.get(key, default)

def set_config(key: str, value: Any) -> None:
    """
    设置配置值的快捷方法
    
    Args:
        key: 配置键
        value: 配置值
    """
    config.set(key, value)

def save_config() -> bool:
    """
    保存配置的快捷方法
    
    Returns:
        bool: 是否保存成功
    """
    return config.save()

def reset_config() -> bool:
    """
    重置配置的快捷方法
    
    Returns:
        bool: 是否重置成功
    """
    return config.reset()

def update_config(new_config: Dict[str, Any]) -> bool:
    """
    更新配置的快捷方法
    
    Args:
        new_config: 新的配置字典
        
    Returns:
        bool: 是否更新成功
    """
    return config.update(new_config)